"""
简化版工作流测试脚本
仅测试数据处理部分，不依赖深度学习库
"""

import pandas as pd
import numpy as np
import warnings
import sys
import os
warnings.filterwarnings('ignore')

def test_data_processing_only():
    """仅测试数据处理功能，不涉及深度学习模型"""
    print("🧪 开始数据处理功能测试...")
    
    try:
        # 创建简单的模拟数据函数
        def create_test_data(start_time: str, end_time: str) -> pd.DataFrame:
            start_dt = pd.to_datetime(start_time)
            end_dt = pd.to_datetime(end_time)
            timestamps = pd.date_range(start_dt, end_dt, freq='H')[:-1]
            n_points = len(timestamps)
            
            if n_points == 0:
                return pd.DataFrame(columns=['timestamp', 'swt', 'swh', 'real_load'])
            
            # 生成测试数据
            hours = np.array([ts.hour for ts in timestamps])
            real_load = 100 + 50 * np.sin(2 * np.pi * hours / 24) + np.random.normal(0, 5, n_points)
            swt = 25 + 5 * np.sin(2 * np.pi * hours / 24) + np.random.normal(0, 1, n_points)
            swh = 0.01 + 0.005 * np.random.rand(n_points)
            
            return pd.DataFrame({
                'timestamp': timestamps,
                'swt': swt,
                'swh': swh,
                'real_load': real_load
            })
        
        print("✅ 测试数据生成函数创建成功")
        
        # 测试数据生成
        start_time = "2024-01-01 00:00:00"
        end_time = "2024-01-10 00:00:00"  # 9天数据
        
        test_data = create_test_data(start_time, end_time)
        print(f"✅ 测试数据生成成功: {len(test_data)} 条记录")
        
        # 验证数据格式
        required_cols = ['timestamp', 'swt', 'swh', 'real_load']
        missing_cols = [col for col in required_cols if col not in test_data.columns]
        if missing_cols:
            print(f"❌ 数据格式错误，缺少列: {missing_cols}")
            return False
        else:
            print("✅ 数据格式验证通过")
        
        # 检查数据质量
        print(f"📊 数据质量检查:")
        print(f"   时间范围: {test_data['timestamp'].min()} 至 {test_data['timestamp'].max()}")
        print(f"   负荷范围: {test_data['real_load'].min():.2f} - {test_data['real_load'].max():.2f}")
        print(f"   温度范围: {test_data['swt'].min():.2f} - {test_data['swt'].max():.2f}°C")
        print(f"   含湿量范围: {test_data['swh'].min():.4f} - {test_data['swh'].max():.4f}")
        print(f"   缺失值数量: {test_data.isnull().sum().sum()}")
        
        # 测试时间特征提取
        test_data['hour'] = test_data['timestamp'].dt.hour
        test_data['dayofweek'] = test_data['timestamp'].dt.dayofweek
        test_data['month'] = test_data['timestamp'].dt.month - 1
        test_data['is_weekend'] = (test_data['timestamp'].dt.dayofweek >= 5).astype(int)
        
        print("✅ 时间特征提取成功")
        print(f"   小时范围: {test_data['hour'].min()} - {test_data['hour'].max()}")
        print(f"   星期范围: {test_data['dayofweek'].min()} - {test_data['dayofweek'].max()}")
        print(f"   周末比例: {test_data['is_weekend'].mean()*100:.1f}%")
        
        # 测试序列切片逻辑（不实际创建模型）
        seq_len = 168  # 一周
        pred_len = 24  # 一天
        n_samples = len(test_data) - seq_len - pred_len + 1
        
        if n_samples > 0:
            print(f"✅ 序列切片逻辑验证: 可生成 {n_samples} 个训练样本")
        else:
            print(f"❌ 数据量不足进行序列切片，需要至少 {seq_len + pred_len} 个样本")
            return False
        
        # 测试数据标准化
        from sklearn.preprocessing import StandardScaler
        scaler = StandardScaler()
        normalized_load = scaler.fit_transform(test_data[['real_load']])
        print(f"✅ 数据标准化测试成功，标准化后均值: {normalized_load.mean():.6f}")
        
        print("🎉 数据处理功能测试全部通过!")
        return True
        
    except ImportError as e:
        print(f"❌ 导入失败: {e}")
        print("💡 请安装基础依赖: pip install pandas numpy scikit-learn")
        return False
    except Exception as e:
        print(f"❌ 测试失败: {e}")
        return False

def test_workflow_interface():
    """测试工作流接口设计"""
    print("\n🔌 测试工作流接口设计...")
    
    # 模拟工作流类的基本结构（不导入实际类）
    class MockWorkflow:
        def __init__(self, data_fetch_function):
            self.data_fetch_function = data_fetch_function
            self.seq_len = 168
            self.pred_len = 24
            
        def set_data_fetch_function(self, func):
            self.data_fetch_function = func
            
        def validate_data_function(self, start_time, end_time):
            """验证数据获取函数的输出格式"""
            try:
                data = self.data_fetch_function(start_time, end_time)
                
                # 检查必要列
                required_cols = ['timestamp', 'swt', 'swh', 'real_load']
                missing_cols = [col for col in required_cols if col not in data.columns]
                if missing_cols:
                    return False, f"缺少必要列: {missing_cols}"
                
                # 检查数据类型
                if not pd.api.types.is_datetime64_any_dtype(data['timestamp']):
                    # 尝试转换
                    data['timestamp'] = pd.to_datetime(data['timestamp'])
                
                # 检查数据量
                if len(data) < self.seq_len + self.pred_len:
                    return False, f"数据量不足，需要至少 {self.seq_len + self.pred_len} 个样本"
                
                return True, "数据格式验证通过"
                
            except Exception as e:
                return False, f"数据获取失败: {e}"
    
    # 测试有效的数据函数
    def valid_data_func(start_time, end_time):
        timestamps = pd.date_range(start_time, end_time, freq='H')[:-1]
        n = len(timestamps)
        return pd.DataFrame({
            'timestamp': timestamps,
            'swt': np.random.normal(25, 5, n),
            'swh': np.random.normal(0.01, 0.002, n),
            'real_load': np.random.normal(100, 20, n)
        })
    
    # 测试无效的数据函数
    def invalid_data_func(start_time, end_time):
        return pd.DataFrame({
            'time': ['2024-01-01'],  # 错误的列名
            'temperature': [25],
            'load': [100]
        })
    
    workflow = MockWorkflow(valid_data_func)
    
    # 测试有效函数
    success, message = workflow.validate_data_function("2024-01-01 00:00:00", "2024-01-10 00:00:00")
    if success:
        print("✅ 有效数据函数验证通过")
    else:
        print(f"❌ 有效数据函数验证失败: {message}")
    
    # 测试无效函数
    workflow.set_data_fetch_function(invalid_data_func)
    success, message = workflow.validate_data_function("2024-01-01 00:00:00", "2024-01-02 00:00:00")
    if not success:
        print("✅ 无效数据函数正确检测")
    else:
        print("❌ 应该检测到无效数据函数但未检测到")
    
    print("✅ 工作流接口设计测试完成")

def main():
    """主测试函数"""
    print("🚀 简化版工作流测试")
    print("仅测试数据处理功能，不依赖深度学习库")
    print("=" * 50)
    
    # 基础数据处理测试
    success1 = test_data_processing_only()
    
    if success1:
        # 接口设计测试
        test_workflow_interface()
        
        print("\n" + "=" * 50)
        print("✅ 简化版测试完成!")
        print("\n📋 测试总结:")
        print("   ✓ 数据生成功能正常")
        print("   ✓ 数据格式验证正常")
        print("   ✓ 数据质量检查正常")
        print("   ✓ 时间特征提取正常")
        print("   ✓ 序列切片逻辑正常")
        print("   ✓ 数据标准化正常")
        print("   ✓ 工作流接口设计正常")
        
        print("\n🎯 下一步:")
        print("   1. 安装深度学习依赖: pip install torch")
        print("   2. 运行完整测试: python quick_test.py")
        print("   3. 运行演示程序: python workflow_demo.py")
        print("   4. 集成您的数据获取函数")
        
    else:
        print("\n❌ 基础测试失败，请检查环境配置")
        print("💡 确保安装了: pandas, numpy, scikit-learn")

if __name__ == "__main__":
    main()
